import { watch, ref, reactive, nextTick } from 'vue';

import XEUtils from 'xe-utils';
import TableUtils from '@/components/tables/cfg/table-utils'

import { VfUtils } from '@/utils/vf-utils';
import { TableDataTypes, TableDataType } from '@/base/pojo/TableDataType.js'

export const useDataHandle = ({props, tableRef, tableOptions, templateRow}) => {

  const tableNodeMap = reactive({});

  
  /**
   * 设置表格数据
   *
   * @param {Array} list 表格数据
   * @param {Boolean} isCover 是否覆盖原有数据
   * @returns {Array} 表格数据
   */
  const setTableData = (list, isCover = true) => {
    if (!list.length) {
      tableOptions.loading = false
      return
    } 
    // 组装数据
    let newData = []
    if (!isCover) {
      const oldData = getTableData()
      const existFields = XEUtils.toTreeArray(oldData).map(item => item.field);
      const filterData = XEUtils.clone(list, true).filter(item => !existFields.includes(item.field));
      newData = [ ...oldData, ...filterData ]
    } else {
      newData = XEUtils.clone(list, true)
    }
    // 转换表格而数据
    const finalData = parseTableData(newData, { level: 1 })
    // 设置数据
    tableOptions.data = finalData
    nextTick(() => {
      tableOptions.loading = false
    })
    // 返回转换后的数据
    return finalData
  }
  /**
   * 获取表格数据
   * @returns {Array} 表格数据
   */
  const getTableData = () => {
    const { value: gridRef } = tableRef;
    const result = gridRef.getTableData();
    return convertTableData(XEUtils.clone(result.fullData, true))
  }
  /**
   * 转换表格数据信息
   *
   * @param {Array} tableData 表格数据
   * @param {Object} config 配置信息 {
   *    level: 级别,
   *    parentId: 父级Id
   * }
   * @returns 转换后的数据
   */
  const parseTableData = (tableData, { level=1, parentId=0 }) => {
    if (!tableData) return []
    // let { level = 1, parentId = 0 } = config;
    return tableData.map((col, colIndex) => {
      // 设置ID，作为唯一标识
      col['id'] = col.id || VfUtils.getUUID();
      // 设置级别，便于数据校验
      col['level'] = level;
      // 设置父级ID
      col['parentId'] = col.parentId || parentId;
      // 初始化一些字段信息，并设置默认参数
      Object.entries(templateRow).forEach(([key, value]) => {
        if (!Reflect.has(col, key)) col[key] = value
      })
      // 处理子级
      if (col.children && col.children.length) {
        col['sortable'] = false;
        col['childNum'] = col.children.length;
        delete col.kind;
        delete col.width;
        col.children = parseTableData(col.children, {
          level: level+1,
          childNum: col.children.length,
          parentId: col.id,
          parentIndex: colIndex,
        });
      }
      tableNodeMap[col.id] = col;
      return col;
    })
  }
  /**
   * 过滤表格数据
   * @param {Array} tableData 表格数据
   * @param {Object} config 配置信息
   * @returns {Array} 过滤后的表格数据
   */
  const filterTableData = (tableData, config) => {
    if (!tableData) return [];
    let { excludeIds } = config;
    return tableData.filter((col, colIndex) => {
      if (col.children && col.children.length) {
        col.children = filterTableData(col.children, { excludeIds });
      }
      if (excludeIds.includes(col.id)) {
        return false;
      } else {
        return true;
      }
    });
  };
  /**
   * 封装表格数据
   * @param {Array} tableData 表格数据
   * @returns {Array} 封装后的表格数据
   */
  const convertTableData = (tableData) => {
    if (!tableData) return []
    return tableData.map(col => {
      if (col.fixed === '') {
        delete col.fixed;
      }
      if (col.width === '') {
        delete col.width;
      }
      if (!(col.kind && TableDataTypes.includes(col.kind))) {
        col.format = '';
      }
      if (col.children && col.children.length) {
        col.children = convertTableData(col.children);
      }
      return col;
    });
  }
  /**
   * 校验字段表格数据
   * 
   * @returns info { valid: Boolean, msg: String }
   */
  const validateFieldData = () => {
    const tableData = tableOptions.data;
    const tableArray = XEUtils.toTreeArray(tableData);
    // 校验字段不能为空
    const fieldKeys = Object.keys(XEUtils.countBy(tableArray, 'field'));
    const titleKeys = Object.keys(XEUtils.countBy(tableArray, 'title'));

    for (let item of fieldKeys) {
      if (item) continue;
      return { valid: false, msg: '字段名称中不能存在空值，请检查！' }
    }
    if (fieldKeys.length !== tableArray.length) {
      return { valid: false, msg: '字段名称中存在重复内容，请检查！' }
    }
    for (let item of titleKeys) {
      if (item) continue;
      return { valid: false, msg: '显示名称中不能存在空值，请检查！' }
    }
    return { valid: true, msg: '' }
  }
  /**
   * 校验参数表格数据
   * 
   * @returns info { valid: Boolean, msg: String }
   */
  const validateParamData = () => {
    const tableData = tableOptions.data;
    const tableArray = XEUtils.toTreeArray(tableData);
    // 校验字段不能为空
    const fieldKeys = Object.keys(XEUtils.countBy(tableArray, 'field'));

    for (let item of fieldKeys) {
      if (item) continue;
      return { valid: false, msg: '参数字段中不能存在空值，请检查！' }
    }
    if (fieldKeys.length !== tableArray.length) {
      return { valid: false, msg: '参数字段中存在重复内容，请检查！' }
    }
    return { valid: true, msg: '' }
  }
  /**
   * 获取预览数据
   *
   * @returns Object 预览数据
   */
  const getPreviewTableData = () => {
    const tableColumns = getTableData();
    return {
      data: TableUtils.generateTableData(tableColumns),
      columns: tableColumns,
    };
  };

  return {
    tableNodeMap,
    setTableData,
    getTableData,
    parseTableData,
    filterTableData,
    validateFieldData,
    validateParamData,
    getPreviewTableData
  }
}